home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / RockRidge / mail / pp / pp-6.0 / Src / lconsole / lconsole.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-12-18  |  4.6 KB  |  302 lines
  1. /* lconsole.c: driver and main routine for the line console */
  2.  
  3. # ifndef lint
  4. static char Rcsid[] = "@(#)$Header: /xtel/pp/pp-beta/Src/lconsole/RCS/lconsole.c,v 6.0 1991/12/18 20:27:16 jpo Rel $";
  5. # endif
  6.  
  7. /*
  8.  * $Header: /xtel/pp/pp-beta/Src/lconsole/RCS/lconsole.c,v 6.0 1991/12/18 20:27:16 jpo Rel $
  9.  *
  10.  * $Log: lconsole.c,v $
  11.  * Revision 6.0  1991/12/18  20:27:16  jpo
  12.  * Release 6.0
  13.  *
  14.  */
  15.  
  16. #include "lconsole.h"
  17. #include "qmgr-int.h"
  18. #include <varargs.h>
  19.  
  20. static char    *myname;
  21.  
  22. int verbose;
  23. int authenticate;
  24. int console_fd = NOTOK;
  25. int accessmode = 0;
  26. int indent = 0;
  27.  
  28. char *host = NULLCP;
  29. char *realhost = NULLCP;
  30. char *remoteversion = NULLCP;
  31. char *user = NULLCP;
  32. char *passwd = NULLCP;
  33. FILE    *fp_in = stdin;
  34. int    batch = 0;
  35.  
  36. main (argc, argv)
  37. int    argc;
  38. char    **argv;
  39. {
  40.     extern char    *optarg;
  41.     extern int    optind;
  42.     int    opt;
  43.     char *vec[NVARGS];
  44.     int vecp;
  45.     char *myhost, *mypasswd, *myuser;
  46.     char **op = NULLVP;
  47.     int status;
  48.  
  49.     myname = argv[0];
  50.     myhost = mypasswd = myuser = NULLCP;
  51.     if (isatty(2))
  52.         verbose = 1;
  53.     while((opt = getopt(argc, argv, "bQ:u:p:")) != EOF)
  54.         switch (opt) {
  55.             case 'Q':
  56.             myhost = optarg;
  57.             break;
  58.  
  59.             case 'u':
  60.             authenticate = TRUE;
  61.             myuser = optarg;
  62.             break;
  63.  
  64.             case 'p':
  65.             authenticate = TRUE;
  66.             mypasswd = optarg;
  67.             break;
  68.  
  69.             case 'b':
  70.             batch = 1;
  71.             break;
  72.  
  73.             default:
  74.             fprintf (stderr, "Usage: %s\n", myname);
  75.             break;
  76.         }
  77.     argc -= optind;
  78.     argv += optind;
  79.     if (argc > 0)
  80.         op = argv;
  81.  
  82.     if (myhost) {
  83.         vecp = 0;
  84.         vec[vecp++] = "open";
  85.         vec[vecp++] = myhost;
  86.         if (myuser) {
  87.             vec[vecp++] = myuser;
  88.             if (mypasswd)
  89.                 vec[vecp++] = mypasswd;
  90.         }
  91.         vec[vecp] = NULLCP;
  92.  
  93.         if (console_loop (vec, NOTOK) != OK && op)
  94.             exit (1);
  95.     }
  96.  
  97.     if(op) {
  98.         for (vecp = 0; *op; op ++)
  99.             vec[vecp++] = *op;
  100.         vec[vecp] = NULLCP;
  101.  
  102.         if (console_loop (vec, NOTOK) != OK)
  103.             status = 1;
  104.     }
  105.     else
  106.         status = interactive ();
  107.  
  108.     if (console_fd != NOTOK) {
  109.         vecp = 0;
  110.         vec[vecp++] = "close";
  111.         vec[vecp++] = NULLCP;
  112.  
  113.         (void) console_loop (vec, NOTOK);
  114.     }
  115.  
  116.     exit(status); /* NOTREACHED */
  117. }
  118.  
  119. int interactive ()
  120. {
  121.     char *vec[NVARGS];
  122.     int status;
  123.     char buffer[BUFSIZ];
  124.     int i;
  125.  
  126.     for (;;) {
  127.         if (getline ("%s> ", buffer) == NOTOK)
  128.             break;
  129.         if (buffer[0] == NULL || buffer[0] == '#')
  130.             continue;
  131.  
  132.         for (i = 0; i < NVARGS; i++)
  133.             vec[i] = NULLCP;
  134.         if (sstr2arg (buffer, NVARGS, vec, " \t") < 1 ||
  135.             *vec[0] == NULL)
  136.             continue;
  137.  
  138.         switch (console_loop (vec, OK)) {
  139.             case NOTOK:
  140.             status = 1;
  141.             break;
  142.  
  143.             case OK:
  144.             continue;
  145.  
  146.             case DONE:
  147.             status = 0;
  148.             break;
  149.         }
  150.         break;
  151.     }
  152.     return status;
  153. }
  154.  
  155. int console_loop (vec, retval)
  156. char **vec;
  157. int retval;
  158. {
  159.     struct lc_dispatch *ds;
  160.  
  161.     if ((ds = getds (*vec)) == NULL)
  162.         return retval;
  163.  
  164.  
  165.     if (console_fd == NOTOK) {
  166.         if (ds -> flags & LC_OPEN) {
  167.             advise (NULLCP, "not connected to a queue manager");
  168.             return retval;
  169.         }
  170.     }
  171.     else if (ds -> flags & LC_CLOSE) {
  172.         advise (NULLCP, "already connected to a queue manager");
  173.         return retval;
  174.     }
  175.     if ((ds -> flags & LC_AUTH) && accessmode != FULL_ACCESS) {
  176.         advise (NULLCP, "Operation requires full access rights");
  177.         return retval;
  178.     }
  179.  
  180.     switch ((*ds -> fnx)(vec)) {
  181.         default:
  182.         case NOTOK:
  183.         return retval;
  184.  
  185.         case OK:
  186.         return OK;
  187.  
  188.         case DONE:
  189.         return DONE;
  190.     }
  191. }
  192.  
  193.  
  194. int getline (prompt, buffer)
  195. char *prompt, *buffer;
  196. {
  197.     int c;
  198.     char *cp, *ep;
  199.  
  200.     if (!batch) {
  201.         printf (prompt, console_fd == NOTOK ? myname : realhost);
  202.         (void) fflush (stdout);
  203.     }
  204.  
  205.     for (ep = (cp = buffer) + BUFSIZ - 1; (c = getc (fp_in)) != '\n';) {
  206.         if (c == EOF) {
  207.             if (!batch)
  208.                 putchar ('\n');
  209.             clearerr(fp_in);
  210.             return NOTOK;
  211.         }
  212.         if (cp < ep)
  213.             *cp ++ = c;
  214.         
  215.     }
  216.     *cp = NULL;
  217.     return OK;
  218. }
  219. #ifndef lint
  220. void    _advise ();
  221.  
  222.  
  223. void    adios (va_alist)
  224. va_dcl
  225. {
  226.     va_list ap;
  227.  
  228.     va_start (ap);
  229.  
  230.     _advise (ap);
  231.  
  232.     va_end (ap);
  233.  
  234.     _exit (1);
  235. }
  236. #else
  237. /* VARARGS */
  238.  
  239. void    adios (what, fmt)
  240. char   *what,
  241.        *fmt;
  242. {
  243.     adios (what, fmt);
  244. }
  245. #endif
  246.  
  247.  
  248. #ifndef lint
  249. void    advise (va_alist)
  250. va_dcl
  251. {
  252.     va_list ap;
  253.  
  254.     va_start (ap);
  255.  
  256.     _advise (ap);
  257.  
  258.     va_end (ap);
  259. }
  260.  
  261.  
  262. static void  _advise (ap)
  263. va_list ap;
  264. {
  265.     char    buffer[BUFSIZ];
  266.  
  267.     asprintf (buffer, ap);
  268.  
  269.     (void) fflush (stdout);
  270.  
  271.     fprintf (stderr, "%s: ", myname);
  272.     (void) fputs (buffer, stderr);
  273.     (void) fputc ('\n', stderr);
  274.  
  275.     (void) fflush (stderr);
  276. }
  277. #else
  278. /* VARARGS */
  279.  
  280. void    advise (what, fmt)
  281. char   *what,
  282.        *fmt;
  283. {
  284.     advise (what, fmt);
  285. }
  286. #endif
  287.  
  288. char *datasize (n, units)
  289. int n;
  290. char *units;
  291. {
  292.     static char dbuf[512];
  293.  
  294.     if (n < 1000)
  295.         (void) sprintf (dbuf, "%d%s", n, units);
  296.     else if (n < 100000)
  297.         (void) sprintf (dbuf, "%.2lfK%s", (double)n/1000.0, units);
  298.     else
  299.         (void) sprintf (dbuf, "%.2lfM%s", (double)n/1000000.0, units);
  300.     return dbuf;
  301. }
  302.